/*
 * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "thermal_mgr_policy_test.h"

#include "power_mgr_client.h"
#include "thermal_mgr_client.h"
#include "mock_thermal_mgr_client.h"
#include "modulemgr.h"

#define private   public
#define protected public
#include "thermal_service.h"
#include "thermal_srv_config_parser.h"
#include "thermal_srv_sensor_info.h"
#include "v1_1/ithermal_interface.h"
#include "v1_1/thermal_types.h"
#undef private
#undef protected

using namespace testing::ext;
using namespace OHOS::PowerMgr;
using namespace OHOS;
using namespace std;

namespace {
const std::string SYSTEM_THERMAL_SERVICE_CONFIG_PATH = "/system/etc/thermal_config/thermal_service_config.xml";
sptr<ThermalService> g_service = nullptr;
const int32_t LEVEL_0 = 0;
const int32_t LEVEL_1 = 1;
const int32_t LEVEL_2 = 2;
const int32_t LEVEL_3 = 3;
const int32_t LEVEL_4 = 4;
}

void ThermalMgrPolicyTest::TearDown()
{
    g_service->SetScene("");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 0;
    event.info.push_back(info1);
    info1.type = "ap";
    event.info.push_back(info1);
    info1.type = "ambient";
    event.info.push_back(info1);
    info1.type = "shell";
    event.info.push_back(info1);
    info1.type = "pa";
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
}

void ThermalMgrPolicyTest::SetUpTestCase()
{
    g_service = ThermalService::GetInstance();
    g_service->InitSystemTestModules();
    g_service->OnStart();
    g_service->InitStateMachine();
    g_service->InitActionManager();
    g_service->GetBaseinfoObj()->Init();
    g_service->GetObserver()->InitSensorTypeMap();
}

void ThermalMgrPolicyTest::TearDownTestCase()
{
    g_service->OnStop();
}

namespace {
/**
 * @tc.name: ThermalMgrPolicyTest001
 * @tc.desc: test get current configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp
 * @tc.result level 1
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest001, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest001 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_1) << "ThermalMgrPolicyTest001 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest001 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest002
 * @tc.desc: test get current configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp
 * @tc.result level 2
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest002, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest002 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_2) << "ThermalMgrPolicyTest002 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest002 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest003
 * @tc.desc: test get current configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp
 * @tc.result level 3
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest003, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest003 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_3) << "ThermalMgrPolicyTest003 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest003 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest004
 * @tc.desc: test get current configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp
 * @tc.result level 4
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest004, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest004 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 48100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_4) << "ThermalMgrPolicyTest004 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest004 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest005
 * @tc.desc: test level asc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp
 * @tc.result level 1 ==> level 4
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest005, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest005 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_1) << "ThermalMgrPolicyTest005 failed";
    event.info.clear();

    info1.temp = 48100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_4) << "ThermalMgrPolicyTest005 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest005 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest006
 * @tc.desc: test level asc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp
 * @tc.result level 2 ==> level 4
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest006, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest006 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_2) << "ThermalMgrPolicyTest006 failed";
    event.info.clear();

    info1.temp = 48100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_4) << "ThermalMgrPolicyTest006 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest006 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest007
 * @tc.desc: test level desc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp
 * @tc.result level 4 ===> level 1
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest007, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest007 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 48200;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_4) << "ThermalMgrPolicyTest007 failed";
    event.info.clear();

    info1.temp = 40900;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_1) << "ThermalMgrPolicyTest007 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest007 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest008
 * @tc.desc: test level desc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp
 * @tc.result level 3 ===> level 0
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest008, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest008 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_3) << "ThermalMgrPolicyTest008 failed";
    event.info.clear();

    info1.temp = 37000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_0) << "ThermalMgrPolicyTest008 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest008 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest009
 * @tc.desc: test get current configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 1
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest009, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest009 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = -10000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_1) << "ThermalMgrPolicyTest009 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest009 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest010
 * @tc.desc: test get current configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 2
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest010, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest010 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = -15000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_2) << "ThermalMgrPolicyTest010 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest010 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest011
 * @tc.desc: test get current configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 3
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest011, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest011 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = -20100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_3) << "ThermalMgrPolicyTest011 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest011 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest012
 * @tc.desc: test get current configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 4
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest012, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest012 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = -22000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_4) << "ThermalMgrPolicyTest012 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest012 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest013
 * @tc.desc: test level asc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 1 ==> level 4
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest013, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest013 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = -10000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_1) << "ThermalMgrPolicyTest013 failed";
    event.info.clear();

    info1.temp = -22000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_4) << "ThermalMgrPolicyTest013 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest013 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest014
 * @tc.desc: test level asc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp
 * @tc.result level 2 ==> level 4
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest014, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest014 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = -15000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_2) << "ThermalMgrPolicyTest014 failed";
    event.info.clear();

    info1.temp = -22000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_4) << "ThermalMgrPolicyTest014 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest014 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest015
 * @tc.desc: test level desc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp
 * @tc.result level 4 ===> level 1
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest015, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest015 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = -22000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_4) << "ThermalMgrPolicyTest015 failed";
    event.info.clear();

    info1.temp = -10000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_1) << "ThermalMgrPolicyTest015 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest015 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest016
 * @tc.desc: test level desc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp
 * @tc.result level 3 ===> level 0
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest016, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest016 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = -19100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_3) << "ThermalMgrPolicyTest016 failed";
    event.info.clear();

    info1.temp = -1000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_0) << "ThermalMgrPolicyTest016 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest016 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest017
 * @tc.desc: test level asc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set PA temp, High Temp With Aux sensor
 * @tc.result level 1
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest017, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest017 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "pa";
    info1.temp = 41000;
    event.info.push_back(info1);
    info1.type = "ambient";
    info1.temp = 10000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_1) << "ThermalMgrPolicyTest017 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest017 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest018
 * @tc.desc: test level asc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set PA temp, High Temp With Aux sensor
 * @tc.result level 1
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest018, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest018 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "pa";
    info1.temp = 44000;
    event.info.push_back(info1);
    info1.type = "ambient";
    info1.temp = 10000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_2) << "ThermalMgrPolicyTest018 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest018 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest019
 * @tc.desc: test level asc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set PA temp, High Temp With Aux sensor
 * @tc.result level 0
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest019, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest019 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "pa";
    info1.temp = 44000;
    event.info.push_back(info1);
    info1.type = "ambient";
    info1.temp = 1000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_0) << "ThermalMgrPolicyTest019 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest019 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest020
 * @tc.desc: test level asc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set PA temp, High Temp With Aux sensor
 * @tc.result level 1
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest020, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest020 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "ap";
    info1.temp = 78000;
    event.info.push_back(info1);
    info1.type = "ambient";
    info1.temp = 1000;
    event.info.push_back(info1);
    info1.type = "shell";
    info1.temp = 2000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_1) << "ThermalMgrPolicyTest020 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest020 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest021
 * @tc.desc: test level asc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set PA temp, High Temp With Aux sensor
 * @tc.result level 0
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest021, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest021 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "ap";
    info1.temp = 78000;
    event.info.push_back(info1);
    info1.type = "ambient";
    info1.temp = 1000;
    event.info.push_back(info1);
    info1.type = "shell";
    info1.temp = -100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
    EXPECT_TRUE(value == LEVEL_0) << "ThermalMgrPolicyTest021 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest021 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest022
 * @tc.desc: test get charge currentby setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set BATTERY temp, state not satisfied
 * @tc.result level 1, current 1800
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest022, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest022 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BATTERY_CHARGER_CURRENT_PATH));
    int32_t currentNow = 1800;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest022 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest022 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest023
 * @tc.desc: test get charge currentby setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set BATTERY temp, state: scene = "cam"
 * @tc.result level 1, current 1200
 * @tc.require: issueI5HWGZ
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest023, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest023 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->SetScene("cam");
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BATTERY_CHARGER_CURRENT_PATH));
    int32_t currentNow = 1200;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest023 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest023 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest024
 * @tc.desc: test get charge currentby setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set BATTERY temp, state not satisfied
 * @tc.result level 2, current 1500
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest024, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest024 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BATTERY_CHARGER_CURRENT_PATH));
    int32_t currentNow = 1500;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest024 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest024 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest025
 * @tc.desc: test get charge currentby setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set BATTERY temp, state: scene = "cam"
 * @tc.result level 2, current 1000
 * @tc.require: issueI5HWGZ
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest025, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest025 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->SetScene("cam");
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BATTERY_CHARGER_CURRENT_PATH));
    int32_t currentNow = 1000;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest025 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest025 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest026
 * @tc.desc: test get charge currentby setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set BATTERY temp, state not satisfied
 * @tc.result level 3, current 1300
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest026, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest026 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BATTERY_CHARGER_CURRENT_PATH));
    int32_t currentNow = 1300;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest026 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest026 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest027
 * @tc.desc: test get charge currentby setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set BATTERY temp, state: scene = "cam"
 * @tc.result level 3, current 800
 * @tc.require: issueI5HWGZ
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest027, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest027 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->SetScene("cam");
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BATTERY_CHARGER_CURRENT_PATH));
    int32_t currentNow = 800;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest027 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest027 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest028
 * @tc.desc: test get current configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 1 current 1850
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest028, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest028 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = -10000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BATTERY_CHARGER_CURRENT_PATH));
    int32_t currentNow = 1850;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest028 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest028 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest029
 * @tc.desc: test get current configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 2 current 1550
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest029, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest029 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = -14100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BATTERY_CHARGER_CURRENT_PATH));
    int32_t currentNow = 1550;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest029 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest029 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest030
 * @tc.desc: test get current configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 3 current 1150
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest030, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest030 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = -19100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BATTERY_CHARGER_CURRENT_PATH));
    int32_t currentNow = 1150;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest030 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest030 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest031
 * @tc.desc: test get brightness configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 1 brightness factor is 1.0
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest031, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest031 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 3) == "1.0") << "ThermalMgrPolicyTest031 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest031 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest032
 * @tc.desc: test get brightness configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 2 brightness factor is 0.9
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest032, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest032 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 3) == "0.9") << "ThermalMgrPolicyTest032 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest032 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest033
 * @tc.desc: test get brightness configured level by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 3 brightness factor is 0.8
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest033, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest033 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 3) == "0.8") << "ThermalMgrPolicyTest033 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest033 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest034
 * @tc.desc: test level asc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set PA temp, High Temp With Aux sensor
 * @tc.result level 1 brightness factor is 0.7
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest034, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest034 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "pa";
    info1.temp = 41000;
    event.info.push_back(info1);
    info1.type = "ambient";
    info1.temp = 10000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 3) == "0.7") << "ThermalMgrPolicyTest034 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest034 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest035
 * @tc.desc: test level asc logic by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set PA temp, High Temp With Aux sensor
 * @tc.result level 2 brightness factor is 0.6
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest035, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest035 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "pa";
    info1.temp = 44000;
    event.info.push_back(info1);
    info1.type = "ambient";
    info1.temp = 10000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 3) == "0.6") << "ThermalMgrPolicyTest035 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest035 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest036
 * @tc.desc: get process and shutdown value
 * @tc.type: FEATURE
 * @tc.cond: Set AP temp, High Temp With Aux sensor
 * @tc.result level 1, process 3, shutdown 1
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest036, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest036 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "ap";
    info1.temp = 78000;
    event.info.push_back(info1);
    info1.type = "ambient";
    info1.temp = 10000;
    event.info.push_back(info1);
    info1.type = "shell";
    info1.temp = 3000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(PROCESS_PATH));
    if (PowerMgrClient::GetInstance().IsScreenOn()) {
        EXPECT_TRUE(value == 3) << "ThermalMgrPolicyTest036 failed";
    } else {
        EXPECT_TRUE(value == 0) << "ThermalMgrPolicyTest036 failed";
    }

    value = ConvertInt(GetNodeValue(SHUTDOWN_PATH));
    if (PowerMgrClient::GetInstance().IsScreenOn()) {
        EXPECT_EQ(true, value == 1) << "ThermalMgrPolicyTest036 failed";
    } else {
        EXPECT_EQ(true, value == 0) << "ThermalMgrPolicyTest036 failed";
    }
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest036 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest037
 * @tc.desc: test get process value by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 1 procss 1
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest037, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest037 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(PROCESS_PATH));
    EXPECT_TRUE(value == LEVEL_3) << "ThermalMgrPolicyTest037 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest037 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest038
 * @tc.desc: test get process value by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 2 procss 2
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest038, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest038 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(PROCESS_PATH));
    EXPECT_TRUE(value == LEVEL_2) << "ThermalMgrPolicyTest038 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest038 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest039
 * @tc.desc: test get process value by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 3 procss 1
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest039, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest039 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(PROCESS_PATH));
    EXPECT_TRUE(value == LEVEL_1) << "ThermalMgrPolicyTest039 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest039 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest040
 * @tc.desc: test get process by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set PA temp, High Temp With Aux sensor
 * @tc.result level 1 process 2
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest040, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest040 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "pa";
    info1.temp = 41000;
    event.info.push_back(info1);
    info1.type = "ambient";
    info1.temp = 10000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(PROCESS_PATH);
    int32_t value = ConvertInt(ret);
    EXPECT_TRUE(value == LEVEL_2) << "ThermalMgrPolicyTest040 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest040 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest041
 * @tc.desc: test get process by setting temp
 * @tc.type: FEATURE
 * @tc.cond: Set PA temp, High Temp With Aux sensor
 * @tc.result level 2 process 3
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest041, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest041 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "pa";
    info1.temp = 44000;
    event.info.push_back(info1);
    info1.type = "ambient";
    info1.temp = 10000;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(PROCESS_PATH));
    EXPECT_TRUE(value == LEVEL_3) << "ThermalMgrPolicyTest041 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest041 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest042
 * @tc.desc: get the config current by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp, charge_type: buck
 * @tc.result level 1, current 1200
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest042, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest042 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BUCK_CURRENT_PATH));
    int32_t currentNow = 1200;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest042 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest042 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest043
 * @tc.desc: get the config voltage by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp, charge_type: sc
 * @tc.result level 1, voltage 4000
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest043, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest043 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(SC_VOLTAGE_PATH));
    int32_t voltage = 4000;
    EXPECT_TRUE(value == voltage) << "ThermalMgrPolicyTest043 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest043 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest044
 * @tc.desc: get the config voltage by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp, charge_type: buck
 * @tc.result level 1, voltage 3000
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest044, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest044 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BUCK_VOLTAGE_PATH));
    int32_t voltage = 3000;
    EXPECT_TRUE(value == voltage) << "ThermalMgrPolicyTest044 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest044 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest045
 * @tc.desc: get the config current by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp, charge_type: buck
 * @tc.result level 2, current 1000
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest045, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest045 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BUCK_CURRENT_PATH));
    int32_t currentNow = 1000;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest045 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest045 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest046
 * @tc.desc: get the config voltage by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp, charge_type: sc
 * @tc.result level 2， voltage 3000
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest046, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest046 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(SC_VOLTAGE_PATH));
    int32_t voltage = 3000;
    EXPECT_TRUE(value == voltage) << "ThermalMgrPolicyTest046 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest046 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest047
 * @tc.desc: get the config voltage by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp, charge_type: buck
 * @tc.result level 2, voltage 2000
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest047, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest047 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BUCK_VOLTAGE_PATH));
    int32_t voltage = 2000;
    EXPECT_TRUE(value == voltage) << "ThermalMgrPolicyTest047 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest047 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest048
 * @tc.desc: get the config current by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp, charge_type: buck
 * @tc.result level 3, current 800
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest048, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest048 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    int32_t value = ConvertInt(GetNodeValue(BUCK_CURRENT_PATH));
    int32_t currentNow = 800;
    EXPECT_TRUE(value == currentNow) << "ThermalMgrPolicyTest048 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest048 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest049
 * @tc.desc: get the config voltage by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp, charge_type: sc
 * @tc.result level 3, voltage 2000
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest049, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest049 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(SC_VOLTAGE_PATH);
    int32_t value = ConvertInt(ret);
    EXPECT_TRUE(value == 2000) << "ThermalMgrPolicyTest049 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest049 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest050
 * @tc.desc: get the config voltage by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, High Temp, charge_type: buck
 * @tc.result level 3, voltage 1000
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest050, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest050 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(BUCK_VOLTAGE_PATH);
    int32_t value = ConvertInt(ret);
    EXPECT_TRUE(value == 1000) << "ThermalMgrPolicyTest050 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest050 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest053
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 1, scene cam, brightness factor is 0.99
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest053, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest053 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->SetScene("cam");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.99") << "ThermalMgrPolicyTest053 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest053 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest054
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 2, scene cam, brightness factor is 0.98
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest054, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest054 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->SetScene("cam");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.89") << "ThermalMgrPolicyTest054 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest054 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest055
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 3, scene cam, brightness factor is 0.97
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest055, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest055 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->SetScene("cam");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.79") << "ThermalMgrPolicyTest055 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest055 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest056
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 1, scene call, brightness factor is 0.98
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest056, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest056 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->SetScene("call");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.98") << "ThermalMgrPolicyTest056 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest056 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest057
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 2, scene call, brightness factor is 0.88
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest057, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest057 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->SetScene("call");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.88") << "ThermalMgrPolicyTest057 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest057 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest058
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 3, scene call, brightness factor is 0.78
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest058, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest058 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->SetScene("call");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.78") << "ThermalMgrPolicyTest058 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest058 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest059
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 1, scene game, brightness factor is 0.97
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest059, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest059 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->SetScene("game");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.97") << "ThermalMgrPolicyTest059 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest059 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest060
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 2, scene game, brightness factor is 0.87
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest060, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest060 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->SetScene("game");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.87") << "ThermalMgrPolicyTest060 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest060 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest061
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 3, scene game, brightness factor is 0.77
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest061, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest061 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->SetScene("game");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.77") << "ThermalMgrPolicyTest061 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest061 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest062
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 1, scene test, brightness factor is 0.91
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest062, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest062 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->SetScene("test");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.91") << "ThermalMgrPolicyTest062 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest062 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest063
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 1, brightness factor is 1.0; scene game, brightness factor is 0.97
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest063, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest063 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 3) == "1.0") << "ThermalMgrPolicyTest063 failed";
    event.info.clear();

    g_service->SetScene("game");
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.97") << "ThermalMgrPolicyTest063 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest063 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest064
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result level 1, scene call, brightness factor is 0.98; scene empty, brightness factor is 1.0
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest064, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest064 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->SetScene("call");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.98") << "ThermalMgrPolicyTest064 failed";
    event.info.clear();

    g_service->SetScene("");
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 3) == "1.0") << "ThermalMgrPolicyTest064 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest064 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest065
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result scene cam, level 1, brightness factor is 0.99
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest065, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest065 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->SetScene("cam");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.99") << "ThermalMgrPolicyTest065 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest065 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest066
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result scene call, level 2, brightness factor is 0.88
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest066, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest066 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->SetScene("call");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.88") << "ThermalMgrPolicyTest066 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest066 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest067
 * @tc.desc: test set brightness according to the scene
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp, Lower Temp
 * @tc.result scene game, level 3, brightness factor is 0.77
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest067, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest067 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->SetScene("game");
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(LCD_PATH);
    EXPECT_TRUE(ret.substr(0, 4) == "0.77") << "ThermalMgrPolicyTest066 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest067 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest068
 * @tc.desc: get the config volume by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp
 * @tc.result level 1, volume 1.0
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest068, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest068 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(VOLUME_PATH);
    EXPECT_TRUE(ret.substr(0, 3) == "1.0") << "ThermalMgrPolicyTest068 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest068 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest069
 * @tc.desc: get the config current by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp
 * @tc.result level 2, volume 0.8
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest069, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest069 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(VOLUME_PATH);
    EXPECT_TRUE(ret.substr(0, 3) == "0.8") << "ThermalMgrPolicyTest069 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest069 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest070
 * @tc.desc: get the config current by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp
 * @tc.result level 3, volume 0.7
 * @tc.require: issueI5HWH6
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest070, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest070 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 46100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(VOLUME_PATH);
    EXPECT_TRUE(ret.substr(0, 3) == "0.7") << "ThermalMgrPolicyTest070 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest070 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest071
 * @tc.desc: test GetThermalSensorTemp function
 * @tc.type: FUNC
 * @tc.cond: Set Battery temp
 * @tc.result: Function return value is equal to the set value
 * @tc.require: issueI63SZ4
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest071, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest071 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 40100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    ThermalSrvSensorInfo info;
    bool thermalInfoRet = false;
    g_service->GetThermalSrvSensorInfo(static_cast<int32_t>(SensorType::BATTERY), info, thermalInfoRet);
    EXPECT_TRUE(thermalInfoRet);
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest071 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest072
 * @tc.desc: get the config airplane by setting battery temp
 * @tc.type: FEATURE
 * @tc.cond: Set Battery temp
 * @tc.result level 2, airplane 1
 * @tc.require: issueIADG4V
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest072, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest072 function start!");
    HdfThermalCallbackInfo event;
    ThermalZoneInfo info1;
    info1.type = "battery";
    info1.temp = 43100;
    event.info.push_back(info1);
    g_service->HandleThermalCallbackEvent(event);
    std::string ret = GetNodeValue(AIRPLANE_PATH);
    EXPECT_TRUE(ret == "1") << "ThermalMgrPolicyTest072 failed";
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest072 function end!");
}

/**
 * @tc.name: ThermalMgrPolicyTest073
 * @tc.desc: test DecryptConfig
 * @tc.type: FUNC
 */
HWTEST_F (ThermalMgrPolicyTest, ThermalMgrPolicyTest073, Function|MediumTest|Level2)
{
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest073 function start!");
    string path = "test";
    string result = "";
#if (defined(__aarch64__) || defined(__x86_64__))
    constexpr const char* THERMAL_PLUGIN_AUTORUN_PATH = "/system/lib64/thermalplugin/autorun";
#else
    constexpr const char* THERMAL_PLUGIN_AUTORUN_PATH = "/system/lib/thermalplugin/autorun";
#endif
    ModuleMgrScan(THERMAL_PLUGIN_AUTORUN_PATH);
    bool ret = g_service->GetConfigParser().DecryptConfig(path, result);
    if (result.empty()) {
        EXPECT_FALSE(ret);
    } else {
        EXPECT_TRUE(ret);
    }
    THERMAL_HILOGI(LABEL_TEST, "ThermalMgrPolicyTest073 function end!");
}
}
